<!DOCTYPE html>
<html lang="zh-cn">
<head>
  
    <link type="text/css" rel="stylesheet" href="/bundles/blog-common.css?v=KOZafwuaDasEedEenI5aTy8aXH0epbm6VUJ0v3vsT_Q1"/>
<link id="MainCss" type="text/css" rel="stylesheet" href="/skins/ThinkInside/bundle-ThinkInside.css?v=RRjf6pEarGnbXZ86qxNycPfQivwSKWRa4heYLB15rVE1"/>
<link type="text/css" rel="stylesheet" href="/blog/customcss/428549.css?v=%2fam3bBTkW5NBWhBE%2fD0lcyJv5UM%3d"/>

</head>
<body>
<a name="top"></a>

<div id="page_begin_html"></div><script>load_page_begin_html();</script>

<div id="topics">
	<div class = "post">
		<h1 class = "postTitle">
			<a id="cb_post_title_url" class="postTitle2" href="https://www.cnblogs.com/frankdeng/p/9311438.html">Hadoop（六）MapReduce的入门与运行原理</a>
		</h1>
		<div class="clear"></div>
		<div class="postBody">
			<div id="cnblogs_post_body" class="blogpost-body"><h2>一 MapReduce入门</h2>
<h3>1.1 MapReduce定义</h3>
<p>Mapreduce是一个分布式运算程序的编程框架，是用户开发&ldquo;基于hadoop的数据分析应用&rdquo;的核心框架；</p>
<p>Mapreduce核心功能是将用户编写的业务逻辑代码和自带默认组件整合成一个完整的分布式运算程序，并发运行在一个hadoop集群上。</p>
<h3>1.2 MapReduce优缺点</h3>
<p>1.2.1 优点</p>
<p>1）MapReduce 易于编程。它简单的实现一些接口，就可以完成一个分布式程序，这个分布式程序可以分布到大量廉价的&nbsp;PC 机器运行。也就是说你写一个分布式程序，跟写一个简单的串行程序是一模一样的。&nbsp;就是因为这个特点使得&nbsp;MapReduce 编程变得非常流行。</p>
<p>2）良好的扩展性。当你的计算资源不能得到满足的时候，你可以通过简单的增加机器来扩展它的计算能力。</p>
<p>3）高容错性。MapReduce 设计的初衷就是使程序能够部署在廉价的&nbsp;PC 机器上，这就要求它具有很高的容错性。比如其中一台机器挂了，它可以把上面的计算任务转移到另外一个节点上面上运行，不至于这个任务运行失败，而且这个过程不需要人工参与，而完全是由&nbsp;Hadoop 内部完成的。</p>
<p>4）适合 PB 级以上海量数据的离线处理。这里加红字体离线处理，说明它适合离线处理而不适合在线处理。比如像毫秒级别的返回一个结果，MapReduce 很难做到。</p>
<p>1.2.2 缺点</p>
<p>MapReduce不擅长做实时计算、流式计算、DAG（有向图）计算。</p>
<p>1）实时计算。MapReduce 无法像&nbsp;Mysql 一样，在毫秒或者秒级内返回结果。</p>
<p>2）流式计算。流式计算的输入数据时动态的，而 MapReduce 的输入数据集是静态的，不能动态变化。这是因为&nbsp;MapReduce 自身的设计特点决定了数据源必须是静态的。</p>
<p>3）DAG（有向图）计算。多个应用程序存在依赖关系，后一个应用程序的输入为前一个的输出。在这种情况下，MapReduce 并不是不能做，而是使用后，每个MapReduce 作业的输出结果都会写入到磁盘，会造成大量的磁盘IO，导致性能非常的低下。</p>
<h3>1.3 MapReduce核心思想</h3>
<p><img src="https://images2018.cnblogs.com/blog/1385722/201805/1385722-20180519221642891-774058825.png" alt="" /></p>
<h3>1.4 MapReduce进程</h3>
<p>一个完整的mapreduce程序在分布式运行时有三类实例进程：</p>
<p>1）MrAppMaster：负责整个程序的过程调度及状态协调。</p>
<p>2）MapTask：负责map阶段的整个数据处理流程。</p>
<p>3）ReduceTask：负责reduce阶段的整个数据处理流程。</p>
<h3>1.5 MapReduce编程规范</h3>
<p>用户编写的程序分成三个部分：Mapper，Reducer，Driver(提交运行mr程序的客户端)</p>
<p>1）Mapper阶段</p>
<p>（1）用户自定义的Mapper要继承自己的父类</p>
<p>（2）Mapper的输入数据是KV对的形式（KV的类型可自定义）</p>
<p>（3）Mapper中的业务逻辑写在map()方法中</p>
<p>（4）Mapper的输出数据是KV对的形式（KV的类型可自定义）</p>
<p>（5）map()方法（maptask进程）对每一个&lt;K,V&gt;调用一次</p>
<p>2）Reducer阶段</p>
<p>（1）用户自定义的Reducer要继承自己的父类</p>
<p>（2）Reducer的输入数据类型对应Mapper的输出数据类型，也是KV</p>
<p>（3）Reducer的业务逻辑写在reduce()方法中</p>
<p>（4）Reducetask进程对每一组相同k的&lt;k,v&gt;组调用一次reduce()方法</p>
<p>3）Driver阶段</p>
<p>整个程序需要一个Drvier来进行提交，提交的是一个描述了各种必要信息的job对象</p>
<h3>1.6 MapReduce程序运行流程分析</h3>
<p><span class="s1">1）在MapReduce程序读取文件的输入目录上存放相应的文件。</span></p>
<p><span class="s1">2）客户端程序在submit()方法执行前，获取待处理的数据信息，然后根据集群中参数的配置形成一个任务分配规划。</span></p>
<p><span class="s1">3）客户端提交job.split、jar包、job.xml等文件给yarn，yarn中的resourcemanager启动MRAppMaster。</span></p>
<p><span class="s1">4）MRAppMaster启动后根据本次job的描述信息，计算出需要的maptask实例数量，然后向集群申请机器启动相应数量的maptask进程。</span></p>
<p><span class="s1">5）maptask利用客户指定的inputformat来读取数据，形成输入KV对。</span></p>
<p><span class="s1">6）maptask将输入KV对传递给客户定义的map()方法，做逻辑运算</span></p>
<p><span class="s1">7）map()运算完毕后将KV对收集到maptask缓存。</span></p>
<p><span class="s1">8）maptask缓存中的KV对按照K分区排序后不断写到磁盘文件</span></p>
<p><span class="s1">9）MRAppMaster监控到所有maptask进程任务完成之后，会根据客户指定的参数启动相应数量的reducetask进程，并告知reducetask进程要处理的数据分区。</span></p>
<p><span class="s1">10）Reducetask进程启动之后，根据MRAppMaster告知的待处理数据所在位置，从若干台maptask运行所在机器上获取到若干个maptask输出结果文件，并在本地进行重新归并排序，然后按照相同key的KV为一个组，调用客户定义的reduce()方法进行逻辑运算。</span></p>
<p><span class="s1">11）Reducetask运算完毕后，调用客户指定的outputformat将结果数据输出到外部存储。</span></p>
<p><span class="l"><a href="file:///C:/Users/Administrator/Desktop/images/0cl8n3u4f8h0174v9aclvtt961.pptx" target="_blank"><img src="https://images2018.cnblogs.com/blog/1385722/201805/1385722-20180519222239561-1444192278.png" alt="" /></a></span></p>
<h2>二 Hadoop序列化</h2>
<h3>2.1 为什么要序列化？</h3>
<p>一般来说，&ldquo;活的&rdquo;对象只生存在内存里，关机断电就没有了。而且&ldquo;活的&rdquo;对象只能由本地的进程使用，不能被发送到网络上的另外一台计算机。&nbsp;然而序列化可以存储&ldquo;活的&rdquo;对象，可以将&ldquo;活的&rdquo;对象发送到远程计算机。</p>
<h3>2.2 什么是序列化？</h3>
<p>序列化就是把内存中的对象，转换成字节序列（或其他数据传输协议）以便于存储（持久化）和网络传输。反序列化就是将收到字节序列（或其他数据传输协议）或者是硬盘的持久化数据，转换成内存中的对象。</p>
<h3>2.3 为什么不用Java的序列化？</h3>
<p>Java的序列化是一个重量级序列化框架（Serializable），一个对象被序列化后，会附带很多额外的信息（各种校验信息，header，继承体系等），不便于在网络中高效传输。所以，hadoop自己开发了一套序列化机制（Writable），精简、高效。</p>
<h3>2.4 为什么序列化对Hadoop很重要？</h3>
<p>因为Hadoop在集群之间进行通讯或者RPC调用的时候，需要序列化，而且要求序列化要快，且体积要小，占用带宽要小。所以必须理解Hadoop的序列化机制。序列化和反序列化在分布式数据处理领域经常出现：进程通信和永久存储。然而Hadoop中各个节点的通信是通过远程调用（RPC）实现的，那么 RPC序列化要求具有以下特点：</p>
<p>1）紧凑：紧凑的格式能让我们能充分利用网络带宽，而带宽是数据中心最稀缺的资</p>
<p>2）快速：进程通信形成了分布式系统的骨架，所以需要尽量减少序列化和反序列化的性能开销，这是基本的；</p>
<p>3）可扩展：协议为了满足新的需求变化，所以控制客户端和服务器过程中，需要直接引进相应的协议，这些是新协议，原序列化方式能支持新的协议报文；</p>
<p>4）互操作：能支持不同语言写的客户端和服务端进行交互；</p>
<h3>2.5 常用数据序列化类型</h3>
<p><img src="https://images2018.cnblogs.com/blog/1385722/201805/1385722-20180519222428431-823319878.png" alt="" /></p>
<h3>2.6 自定义bean对象实现序列化接口（Writable）</h3>
<p>1）自定义bean对象要想序列化传输，必须实现序列化接口，需要注意以下7项。</p>
<div class="cnblogs_code">
<pre> // 1 必须实现Writable接口
public class FlowBean implements Writable {
private long upFlow;
private long downFlow;
private long sumFlow;
//2 反序列化时，需要反射调用空参构造函数，所以必须有
public FlowBean() {
     super();
   }
/**
* 3重写序列化方法
* @param out
* @throws IOException
*/

@Override
public void write(DataOutput out) throws IOException {
                 out.writeLong(upFlow);
                 out.writeLong(downFlow);
                 out.writeLong(sumFlow);
}

/**
* 4 重写反序列化方法
* 5 注意反序列化的顺序和序列化的顺序完全一致
* @param in
* @throws IOException
*/
@Override
public void readFields(DataInput in) throws IOException {
      upFlow = in.readLong();
      downFlow = in.readLong();
      sumFlow = in.readLong();
}
// 6要想把结果显示在文件中，需要重写toString()，且用&rdquo;\t&rdquo;分开，方便后续用
@Override
public String toString() {
       return upFlow + "\t" + downFlow + "\t" + sumFlow;

}
//7 如果需要将自定义的bean放在key中传输，则还需要实现comparable接口，因为mapreduce框中的shuffle过程一定会对key进行排序
@Override
public int compareTo(FlowBean o) {
// 倒序排列，从大到小
     return this.sumFlow &gt; o.getSumFlow() ? -1 : 1;
     }
} </pre>
</div>
<p>（1）必须实现Writable接口</p>
<p>（2）反序列化时，需要反射调用空参构造函数，所以必须有空参构造</p>
<p>（3）重写序列化方法</p>
<p>（4）重写反序列化方法</p>
<p>（5）注意反序列化的顺序和序列化的顺序完全一致</p>
<p>（6）要想把结果显示在文件中，需要重写toString()，且用&rdquo;\t&rdquo;分开，方便后续用</p>
<p>（7）如果需要将自定义的bean放在key中传输，则还需要实现comparable接口，因为mapreduce框中的shuffle过程一定会对key进行排序</p>
<p>2）案例实操</p>
<p>详见统计每一个手机号耗费的总上行流量、下行流量、总流量（序列化）。</p>
<h2>三 MapReduce框架原理</h2>
<h3>3.1 MapReduce工作流程</h3>
<p>1）流程示意图</p>
<p><a href="file:///C:/Users/Administrator/Desktop/images/0dt7lqsvm61p3p9vpfki1bm90l.pptx" target="_blank"><span class="l"><img src="https://images2018.cnblogs.com/blog/1385722/201805/1385722-20180519223333888-1999909545.png" alt="" /></span></a></p>
<p><img src="https://images2018.cnblogs.com/blog/1385722/201805/1385722-20180519223637626-1917140492.png" alt="" /></p>
<p><img src="https://images2018.cnblogs.com/blog/1385722/201807/1385722-20180723133256540-1455162702.png" alt="" /></p>
<p>2）流程详解</p>
<p>上面的流程是整个mapreduce最全工作流程，但是shuffle过程只是从第7步开始到第16步结束，具体shuffle过程详解，如下：</p>
<p>1）maptask收集我们的map()方法输出的kv对，放到内存缓冲区中</p>
<p>2）从内存缓冲区不断溢出本地磁盘文件，可能会溢出多个文件</p>
<p>3）多个溢出文件会被合并成大的溢出文件</p>
<p>4）在溢出过程中，及合并的过程中，都要调用partitioner进行分区和针对key进行排序</p>
<p>5）reducetask根据自己的分区号，去各个maptask机器上取相应的结果分区数据</p>
<p>6）reducetask会取到同一个分区的来自不同maptask的结果文件，reducetask会将这些文件再进行合并（归并排序）</p>
<p>7）合并成大文件后，shuffle的过程也就结束了，后面进入reducetask的逻辑运算过程（从文件中取出一个一个的键值对group，调用用户自定义的reduce()方法）</p>
<p>3）注意</p>
<p>Shuffle中的缓冲区大小会影响到mapreduce程序的执行效率，原则上说，缓冲区越大，磁盘io的次数越少，执行速度就越快。</p>
<p>缓冲区的大小可以通过参数调整，参数：io.sort.mb &nbsp;默认100M</p>
<h3>3.2 InputFormat数据输入</h3>
<p>3.2.1 InputFormat接口实现类</p>
<p>InputFormat&nbsp;常见的接口实现类包括：TextInputFormat、KeyValueTextInputFormat、NLineInputFormat、CombineTextInputFormat和自定义InputFormat等。</p>
<p>1）TextInputFormat</p>
<p>TextInputFormat&nbsp;是默认的&nbsp;InputFormat。每条记录是一行输入。键是LongWritable&nbsp;类型，存储该行在整个文件中的字节偏移量。 值是这行的内容，不包括任何行终止符（换行符合回车符），它被打包成一个&nbsp;Text&nbsp;对象。</p>
<p>以下是一个示例，比如，一个分片包含了如下4条文本记录。</p>
<table border="1" cellspacing="0">
<tbody>
<tr>
<td valign="top" width="548">
<p>Rich learning form</p>
<p>Intelligent learning engine</p>
<p>Learning more convenient</p>
<p>From the real demand for more close to the enterprise</p>
</td>
</tr>
</tbody>
</table>
<p>&nbsp;每条记录表示为以下键/值对：</p>
<table border="1" cellspacing="0">
<tbody>
<tr>
<td valign="top" width="548">
<p>(0,Rich learning form)</p>
<p>(19,Intelligent learning engine)</p>
<p>(47,Learning more convenient)</p>
<p>(72,From the real demand for more close to the enterprise)</p>
</td>
</tr>
</tbody>
</table>
<p>&nbsp;很明显，键并不是行号。一般情况下，很难取得行号，因为文件按字节而不是按行切分为分片。</p>
<p>2）KeyValueTextInputFormat</p>
<p>每一行均为一条记录，&nbsp;被分隔符（缺省是tab（\t））分割为key（Text）,value（Text）。可以通过&nbsp;mapreduce.input.keyvaluelinerecordreader.key.value,separator属性（或者旧版本&nbsp;API&nbsp;中的&nbsp;key.value.separator.in.input.line）来设定分隔符。 它的默认值是一个制表符。</p>
<p>以下是一个示例，输入是一个包含4条记录的分片。其中&mdash;&mdash;&gt;表示一个（水平方向的）制表符。</p>
<table border="1" cellspacing="0">
<tbody>
<tr>
<td valign="top" width="548">
<p>line1 &mdash;&mdash;&gt;Rich learning form</p>
<p>line2 &mdash;&mdash;&gt;Intelligent learning engine</p>
<p>line3 &mdash;&mdash;&gt;Learning more convenient</p>
<p>line4 &mdash;&mdash;&gt;From the real demand for more close to the enterprise</p>
</td>
</tr>
</tbody>
</table>
<p>&nbsp;每条记录表示为以下键/值对：</p>
<table border="1" cellspacing="0">
<tbody>
<tr>
<td valign="top" width="548">
<p>(line1,Rich learning form)</p>
<p>(line2,Intelligent learning engine)</p>
<p>(line3,Learning more convenient)</p>
<p>(line4,From the real demand for more close to the enterprise)</p>
</td>
</tr>
</tbody>
</table>
<p>此时的键是每行排在制表符之前的&nbsp;Text&nbsp;序列。</p>
<p>&nbsp;3）NLineInputFormat</p>
<p>通过&nbsp;TextInputFormat&nbsp;和&nbsp;KeyValueTextInputFormat，每个&nbsp;Mapper&nbsp;收到的输入行数不同。行数取决于输入分片的大小和行的长度。 如果希望&nbsp;Mapper&nbsp;收到固定行数的输入，需要将&nbsp;NLineInputFormat&nbsp;作为&nbsp;InputFormat。与&nbsp;TextInputFormat&nbsp;一样， 键是文件中行的字节偏移量，值是行本身。N&nbsp;是每个&nbsp;Mapper&nbsp;收到的输入行数。N&nbsp;设置为1（默认值）时，每个&nbsp;Mapper&nbsp;正好收到一行输入。&nbsp;mapreduce.input.lineinputformat.linespermap&nbsp;属性（在旧版本&nbsp;API&nbsp;中的&nbsp;mapred.line.input.format.linespermap&nbsp;属性）实现&nbsp;N&nbsp;值的设定。</p>
<p>以下是一个示例，仍然以上面的4行输入为例。</p>
<table border="1" cellspacing="0">
<tbody>
<tr>
<td valign="top" width="548">
<p>Rich learning form</p>
<p>Intelligent learning engine</p>
<p>Learning more convenient</p>
<p>From the real demand for more close to the enterprise</p>
</td>
</tr>
</tbody>
</table>
<p>例如，如果&nbsp;N&nbsp;是2，则每个输入分片包含两行。一个&nbsp;mapper&nbsp;收到前两行键值对：</p>
<table border="1" cellspacing="0">
<tbody>
<tr>
<td valign="top" width="548">
<p>(0,Rich learning form)</p>
<p>(19,Intelligent learning engine)</p>
</td>
</tr>
</tbody>
</table>
<p>&nbsp;另一个&nbsp;mapper&nbsp;则收到后两行：</p>
<table border="1" cellspacing="0">
<tbody>
<tr>
<td valign="top" width="548">
<p>(47,Learning more convenient)</p>
<p>(72,From the real demand for more close to the enterprise)</p>
</td>
</tr>
</tbody>
</table>
<p>&nbsp;</p>
<p>这里的键和值与TextInputFormat生成的一样。</p>
<p>3.2.2 自定义InputFormat</p>
<p>1）概述</p>
<p>（1）自定义一个类继承FileInputFormat</p>
<p>（2）改写RecordReader，实现一次读取一个完整文件封装为KV</p>
<p>（3）在输出时使用SequenceFileOutPutFormat输出合并文件</p>
<p>2）案例实操</p>
<p>&nbsp; &nbsp; 详见小文件处理（自定义InputFormat）。</p>
<p>3.2.3 FileInputFormat切片机制</p>
<p>1）job提交流程源码详解</p>
<div class="cnblogs_code">
<pre>waitForCompletion()
submit();
// 1建立连接
connect();
// 1）创建提交job的代理
new Cluster(getConfiguration());
// （1）判断是本地yarn还是远程
initialize(jobTrackAddr, conf);
// 2 提交job
submitter.submitJobInternal(Job.this, cluster)
// 1）创建给集群提交数据的Stag路径
Path jobStagingArea = JobSubmissionFiles.getStagingDir(cluster, conf);
// 2）获取jobid ，并创建job路径
JobID jobId = submitClient.getNewJobID();
// 3）拷贝jar包到集群
copyAndConfigureFiles(job, submitJobDir);
rUploader.uploadFiles(job, jobSubmitDir);
// 4）计算切片，生成切片规划文件
writeSplits(job, submitJobDir);
maps = writeNewSplits(job, jobSubmitDir);
input.getSplits(job);
// 5）向Stag路径写xml配置文件
writeConf(conf, submitJobFile);
conf.writeXml(out);
// 6）提交job,返回提交状态
status = submitClient.submitJob(jobId, submitJobDir.toString(), job.getCredentials()); </pre>
</div>
<p><span class="l"><a href="file:///C:/Users/Administrator/Desktop/images/3ocvkgcaq9k1ab040clc86261t.pptx" target="_blank"><img src="https://images2018.cnblogs.com/blog/1385722/201805/1385722-20180519224414445-157804025.png" alt="" /></a></span></p>
<p>2）FileInputFormat源码解析(input.getSplits(job))</p>
<p>（1）找到你数据存储的目录。</p>
<p>（2）开始遍历处理（规划切片）目录下的每一个文件</p>
<p>（3）遍历第一个文件ss.txt</p>
<p>a）获取文件大小fs.sizeOf(ss.txt);</p>
<p>b）计算切片大小computeSliteSize(Math.max(minSize,Math.min(maxSize,blocksize)))=blocksize=128M</p>
<p>c）默认情况下，切片大小=blocksize</p>
<p>d）开始切，形成第1个切片：ss.txt&mdash;0:128M 第2个切片ss.txt&mdash;128:256M 第3个切片ss.txt&mdash;256M:300M（每次切片时，都要判断切完剩下的部分是否大于块的1.1倍，不大于1.1倍就划分一块切片）</p>
<p>e）将切片信息写到一个切片规划文件中</p>
<p>f）整个切片的核心过程在getSplit()方法中完成。</p>
<p>g）数据切片只是在逻辑上对输入数据进行分片，并不会再磁盘上将其切分成分片进行存储。InputSplit只记录了分片的元数据信息，比如起始位置、长度以及所在的节点列表等。</p>
<p>h）注意：block是HDFS上物理上存储的存储的数据，切片是对数据逻辑上的划分。</p>
<p>（4）提交切片规划文件到yarn上，yarn上的MrAppMaster就可以根据切片规划文件计算开启maptask个数。</p>
<p>3）FileInputFormat中默认的切片机制：</p>
<p>（1）简单地按照文件的内容长度进行切片</p>
<p>（2）切片大小，默认等于block大小</p>
<p>（3）切片时不考虑数据集整体，而是逐个针对每一个文件单独切片</p>
<div class="cnblogs_code">
<pre>比如待处理数据有两个文件：
file1.txt 320M
file2.txt 10M
经过FileInputFormat的切片机制运算后，形成的切片信息如下：
file1.txt.split1-- 0~128
file1.txt.split2-- 128~256
file1.txt.split3-- 256~320
file2.txt.split1-- 0~10M </pre>
</div>
<p>4）FileInputFormat切片大小的参数配置</p>
<p><span class="s1">（1）通过分析源码，在FileInputFormat中，计算切片大小的逻辑：Math.max(minSize, Math.min(maxSize, blockSize));</span></p>
<p><span class="s1">切片主要由这几个值来运算决定</span></p>
<p><span class="s1">mapreduce.input.fileinputformat.split.minsize=1 默认值为1</span></p>
<p><span class="s1">mapreduce.input.fileinputformat.split.maxsize= Long.MAXValue 默认值Long.MAXValue</span></p>
<p><span class="s2">因此，默认情况下，切片大小=blocksize。</span></p>
<p><span class="s1">maxsize（切片最大值）：参数如果调得比blocksize小，则会让切片变小，而且就等于配置的这个参数的值。</span></p>
<p><span class="s1">minsize（切片最小值）：参数调的比blockSize大，则可以让切片变得比blocksize还大。</span></p>
<p>5）获取切片信息API</p>
<div class="cnblogs_code">
<pre>// 根据文件类型获取切片信息
FileSplit inputSplit = (FileSplit) context.getInputSplit();
// 获取切片的文件名称
String name = inputSplit.getPath().getName();</pre>
</div>
<p>3.2.4 CombineTextInputFormat切片机制</p>
<p>关于大量小文件的优化策略</p>
<p>1）默认情况下TextInputformat对任务的切片机制是按文件规划切片，不管文件多小，都会是一个单独的切片，都会交给一个maptask，这样如果有大量小文件，就会产生大量的maptask，处理效率极其低下。</p>
<p>2）优化策略</p>
<p>（1）最好的办法，在数据处理系统的最前端（预处理/采集），将小文件先合并成大文件，再上传到HDFS做后续分析。</p>
<p>（2）补救措施：如果已经是大量小文件在HDFS中了，可以使用另一种InputFormat来做切片（CombineFileInputFormat），它的切片逻辑跟TextFileInputFormat不同：它可以将多个小文件从逻辑上规划到一个切片中，这样，多个小文件就可以交给一个maptask。</p>
<p>（3）优先满足最小切片大小，不超过最大切片大小</p>
<p>CombineTextInputFormat.setMaxInputSplitSize(job, 4194304);// 4m</p>
<p>CombineTextInputFormat.setMinInputSplitSize(job, 2097152);// 2m</p>
<p>举例：0.5m+1m+0.3m+5m=2m + 4.8m=2m + 4m + 0.8m</p>
<p>3）具体实现步骤</p>
<p>// 9 如果不设置InputFormat,它默认用的是TextInputFormat.class</p>
<p>job.setInputFormatClass(CombineTextInputFormat.class)</p>
<p>CombineTextInputFormat.setMaxInputSplitSize(job, 4194304);// 4m</p>
<p>CombineTextInputFormat.setMinInputSplitSize(job, 2097152);// 2m</p>
<p>4）案例实操</p>
<p>详见大量小文件的切片优化（CombineTextInputFormat）。</p>
<h3>3.3 MapTask工作机制</h3>
<p>3.3.1 并行度决定机制</p>
<p>1）问题引出</p>
<p>maptask的并行度决定map阶段的任务处理并发度，进而影响到整个job的处理速度。那么，mapTask并行任务是否越多越好呢？</p>
<p>2）MapTask并行度决定机制</p>
<p>一个job的map阶段MapTask并行度（个数），由客户端提交job时的切片个数决定。</p>
<p><span class="l"><a href="file:///C:/Users/Administrator/Desktop/images/25qk22vhleqncovn6jbt51vgme.pptx" target="_blank"><img src="https://images2018.cnblogs.com/blog/1385722/201805/1385722-20180519225238333-120161098.png" alt="" /></a></span></p>
<p>3.3.2 MapTask工作机制</p>
<p><span class="l"><a href="file:///C:/Users/Administrator/Desktop/images/7h3eluptc0ud5b2p4os363fuuv.pptx" target="_blank"><img src="https://images2018.cnblogs.com/blog/1385722/201805/1385722-20180519225340866-1421944163.png" alt="" /></a></span></p>
<p>（1）Read阶段：Map Task通过用户编写的RecordReader，从输入InputSplit中解析出一个个key/value。</p>
<p>（2）Map阶段：该节点主要是将解析出的key/value交给用户编写map()函数处理，并产生一系列新的key/value。</p>
<p>（3）Collect收集阶段：在用户编写map()函数中，当数据处理完成后，一般会调用OutputCollector.collect()输出结果。在该函数内部，它会将生成的key/value分区（调用Partitioner），并写入一个环形内存缓冲区中。</p>
<p>（4）Spill阶段：即&ldquo;溢写&rdquo;，当环形缓冲区满后，MapReduce会将数据写到本地磁盘上，生成一个临时文件。需要注意的是，将数据写入本地磁盘之前，先要对数据进行一次本地排序，并在必要时对数据进行合并、压缩等操作。</p>
<p><span class="s1">溢写阶段详情：</span></p>
<p><span class="s1">步骤1：利用快速排序算法对缓存区内的数据进行排序，排序方式是，先按照分区编号partition进行排序，然后按照key进行排序。这样，经过排序后，数据以分区为单位聚集在一起，且同一分区内所有数据按照key有序。</span></p>
<p><span class="s1">步骤2：按照分区编号由小到大依次将每个分区中的数据写入任务工作目录下的临时文件output/spillN.out（N表示当前溢写次数）中。如果用户设置了Combiner，则写入文件之前，对每个分区中的数据进行一次聚集操作。</span></p>
<p><span class="s1">步骤3：将分区数据的元信息写到内存索引数据结构SpillRecord中，其中每个分区的元信息包括在临时文件中的偏移量、压缩前数据大小和压缩后数据大小。如果当前内存索引大小超过1MB，则将内存索引写到文件output/spillN.out.index中。</span></p>
<p>（5）Combine阶段：当所有数据处理完成后，MapTask对所有临时文件进行一次合并，以确保最终只会生成一个数据文件。当所有数据处理完后，MapTask会将所有临时文件合并成一个大文件，并保存到文件output/file.out中，同时生成相应的索引文件output/file.out.index。在进行文件合并过程中，MapTask以分区为单位进行合并。对于某个分区，它将采用多轮递归合并的方式。每轮合并io.sort.factor（默认100）个文件，并将产生的文件重新加入待合并列表中，对文件排序后，重复以上过程，直到最终得到一个大文件。让每个MapTask最终只生成一个数据文件，可避免同时打开大量文件和同时读取大量小文件产生的随机读取带来的开销。</p>
<h4 id="blogTitle6">MapTask 并行度经验之谈</h4>
<p>如果硬件配置为 2*12core + 64G，恰当的 map 并行度是大约每个节点 20-100 个 map，最好 每个 map 的执行时间至少一分钟。</p>
<p>1、如果 job 的每个 map 或者 reduce task 的运行时间都只有 30-40 秒钟，那么就减少该 job 的 map 或者 reduce 数，每一个 task(map|reduce)的 setup 和加入到调度器中进行调度，这个 中间的过程可能都要花费几秒钟，所以如果每个 task 都非常快就跑完了，就会在 task 的开 始和结束的时候浪费太多的时间。</p>
<p>配置 task 的 JVM 重用可以改善该问题：</p>
<p>mapred.job.reuse.jvm.num.tasks，默认是 1，表示一个 JVM 上最多可以顺序执行的 task 数目（属于同一个 Job）是 1。也就是说一个 task 启一个 JVM。这个值可以在 mapred-site.xml 中进行更改，当设置成多个，就意味着这多个 task 运行在同一个 JVM 上，但不是同时执行， 是排队顺序执行</p>
<p>2、如果 input 的文件非常的大，比如 1TB，可以考虑将 hdfs 上的每个 blocksize 设大，比如 设成 256MB 或者 512MB</p>
<h3>3.4 Shuffle机制</h3>
<ul>
<li>MapReduce 中，mapper 阶段处理的数据如何传递给 reducer 阶段，是 MapReduce 框架中 最关键的一个流程，这个流程就叫 Shuffle</li>
<li>Shuffle: 数据混洗 &mdash;&mdash;（核心机制：数据分区，排序，局部聚合，缓存，拉取，再合并 排序）</li>
<li>具体来说：就是将 MapTask 输出的处理结果数据，按照 Partitioner 组件制定的规则分发 给 ReduceTask，并在分发的过程中，对数据按 key 进行了分区和排序</li>
</ul>
<p>3.4.1 Shuffle机制</p>
<p>Mapreduce确保每个reducer的输入都是按键排序的。系统执行排序的过程（即将map输出作为输入传给reducer）称为shuffle。</p>
<p><img src="https://images2018.cnblogs.com/blog/1385722/201805/1385722-20180519225534576-201751359.png" alt="" /></p>
<p><img src="https://images2018.cnblogs.com/blog/1385722/201805/1385722-20180519225647713-295898773.png" alt="" /></p>
<p>3.4.2 Partition分区</p>
<p>0）问题引出：要求将统计结果按照条件输出到不同文件中（分区）。比如：将统计结果按照手机归属地不同省份输出到不同文件中（分区）</p>
<p>1）默认partition分区</p>
<div class="cnblogs_code">
<pre>public class HashPartitioner&lt;K, V&gt; extends Partitioner&lt;K, V&gt; {
/** Use {@link Object#hashCode()} to partition. */
public int getPartition(K key, V value, int numReduceTasks) {
return (key.hashCode() &amp; Integer.MAX_VALUE) % numReduceTasks;
    }
}</pre>
</div>
<p>默认分区是根据key的hashCode对reduceTasks个数取模得到的。用户没法控制哪个key存储到哪个分区。</p>
<p>2）自定义Partitioner步骤</p>
<p>（1）自定义类继承Partitioner，重写getPartition()方法</p>
<div class="cnblogs_code">
<pre> public class ProvincePartitioner extends Partitioner&lt;Text, FlowBean&gt; {
@Override
public int getPartition(Text key, FlowBean value, int numPartitions) {
// 1 获取电话号码的前三位
String preNum = key.toString().substring(0, 3);
int partition = 4;
// 2 判断是哪个省
if ("136".equals(preNum)) {
partition = 0;
}else if ("137".equals(preNum)) {
partition = 1;
}else if ("138".equals(preNum)) {
partition = 2;
}else if ("139".equals(preNum)) {
partition = 3;
}
return partition;
}
} </pre>
</div>
<p>（2）在job驱动中，设置自定义partitioner：</p>
<p><span class="s1">job.setPartitionerClass(CustomPartitioner.class);</span></p>
<p>（3）自定义partition后，要根据自定义partitioner的逻辑设置相应数量的reduce task</p>
<p><span class="s1">job.setNumReduceTasks(5);</span></p>
<p>3）注意：</p>
<p>如果reduceTask的数量&gt; getPartition的结果数，则会多产生几个空的输出文件part-r-000xx；</p>
<p>如果1&lt;reduceTask的数量&lt;getPartition的结果数，则有一部分分区数据无处安放，会Exception；</p>
<p>如果reduceTask的数量=1，则不管mapTask端输出多少个分区文件，最终结果都交给这一个reduceTask，最终也就只会产生一个结果文件 part-r-00000；</p>
<p>例如：假设自定义分区数为5，则</p>
<p>（1）job.setNumReduceTasks(1);会正常运行，只不过会产生一个输出文件</p>
<p>（2）job.setNumReduceTasks(2);会报错</p>
<p>（3）job.setNumReduceTasks(6);大于5，程序会正常运行，会产生空文件</p>
<p>4）案例实操</p>
<p>详见将统计结果按照手机归属地不同省份输出到不同文件中（Partitioner）</p>
<p>详见把单词按照ASCII码奇偶分区（Partitioner）</p>
<p>3.4.3 WritableComparable排序</p>
<p>排序是MapReduce框架中最重要的操作之一。Map Task和Reduce Task均会对数据（按照key）进行排序。该操作属于Hadoop的默认行为。任何应用程序中的数据均会被排序，而不管逻辑上是否需要。</p>
<p>对于Map Task，它会将处理的结果暂时放到一个缓冲区中，当缓冲区使用率达到一定阈值后，再对缓冲区中的数据进行一次排序，并将这些有序数据写到磁盘上，而当数据处理完毕后，它会对磁盘上所有文件进行一次合并，以将这些文件合并成一个大的有序文件。</p>
<p>对于Reduce Task，它从每个Map Task上远程拷贝相应的数据文件，如果文件大小超过一定阈值，则放到磁盘上，否则放到内存中。如果磁盘上文件数目达到一定阈值，则进行一次合并以生成一个更大文件；如果内存中文件大小或者数目超过一定阈值，则进行一次合并后将数据写到磁盘上。当所有数据拷贝完毕后，Reduce Task统一对内存和磁盘上的所有数据进行一次合并。</p>
<p>1）排序的分类：</p>
<p>（1）部分排序：</p>
<p>MapReduce根据输入记录的键对数据集排序。保证输出的每个文件内部排序。</p>
<p>（2）全排序：</p>
<p>如何用Hadoop产生一个全局排序的文件？最简单的方法是使用一个分区。但该方法在处理大型文件时效率极低，因为一台机器必须处理所有输出文件，从而完全丧失了MapReduce所提供的并行架构。</p>
<p>替代方案：首先创建一系列排好序的文件；其次，串联这些文件；最后，生成一个全局排序的文件。主要思路是使用一个分区来描述输出的全局排序。例如：可以为上述文件创建3个分区，在第一分区中，记录的单词首字母a-g，第二分区记录单词首字母h-n, 第三分区记录单词首字母o-z。</p>
<p>（3）辅助排序：（GroupingComparator分组）</p>
<p>Mapreduce框架在记录到达reducer之前按键对记录排序，但键所对应的值并没有被排序。甚至在不同的执行轮次中，这些值的排序也不固定，因为它们来自不同的map任务且这些map任务在不同轮次中完成时间各不相同。一般来说，大多数MapReduce程序会避免让reduce函数依赖于值的排序。但是，有时也需要通过特定的方法对键进行排序和分组等以实现对值的排序。</p>
<p>（4）二次排序：</p>
<p>在自定义排序过程中，如果compareTo中的判断条件为两个即为二次排序。</p>
<p>2）自定义排序WritableComparable</p>
<p>（1）原理分析</p>
<p>bean对象实现WritableComparable接口重写compareTo方法，就可以实现排序</p>
<div class="cnblogs_code">
<pre>@Override
public int compareTo(FlowBean o) {
// 倒序排列，从大到小
return this.sumFlow &gt; o.getSumFlow() ? -1 : 1;
} </pre>
</div>
<p>（2）案例实操</p>
<p>详将统计结果按照总流量倒序排序（排序）</p>
<p>详见不同省份输出文件内部排序（部分排序）</p>
<p>3.4.4 GroupingComparator分组（辅助排序）</p>
<p>1）对reduce阶段的数据根据某一个或几个字段进行分组。</p>
<p>2）案例实操</p>
<p>详见求出每一个订单中最贵的商品（GroupingComparator）</p>
<p>3.4.5 Combiner合并</p>
<p>1）combiner是MR程序中Mapper和Reducer之外的一种组件</p>
<p>2）combiner组件的父类就是Reducer</p>
<p>3）combiner和reducer的区别在于运行的位置：</p>
<p>Combiner是在每一个maptask所在的节点运行</p>
<p>Reducer是接收全局所有Mapper的输出结果；</p>
<p>4）combiner的意义就是对每一个maptask的输出进行局部汇总，以减小网络传输量</p>
<p>5）combiner能够应用的前提是不能影响最终的业务逻辑，而且，combiner的输出kv应该跟reducer的输入kv类型要对应起来</p>
<div class="cnblogs_code">
<pre>Mapper
3 5 7 -&gt;(3+5+7)/3=5
2 6 -&gt;(2+6)/2=4
Reducer
(3+5+7+2+6)/5=23/5 不等于 (5+4)/2=9/2 </pre>
</div>
<p>6）自定义Combiner实现步骤：</p>
<p>（1）自定义一个combiner继承Reducer，重写reduce方法</p>
<div class="cnblogs_code">
<pre>public class WordcountCombiner extends Reducer&lt;Text, IntWritable, Text, IntWritable&gt;{
@Override
protected void reduce(Text key, Iterable&lt;IntWritable&gt; values,
Context context) throws IOException, InterruptedException {
int count = 0;
for(IntWritable v :values){
     count = v.get();
   }
context.write(key, new IntWritable(count));
   }
} </pre>
</div>
<p>（2）在job驱动类中设置： &nbsp;</p>
<p><span class="s1">job.setCombinerClass(WordcountCombiner.class);</span></p>
<p>7）案例实操</p>
<p>详见对每一个maptask的输出局部汇总（Combiner）</p>
<h3>3.5 ReduceTask工作机制</h3>
<p>1）设置ReduceTask</p>
<p>reducetask的并行度同样影响整个job的执行并发度和执行效率，但与maptask的并发数由切片数决定不同，Reducetask数量的决定是可以直接手动设置：</p>
<p><span class="s1">//默认值是1，手动设置为4&nbsp; &nbsp; &nbsp; &nbsp;&nbsp;<span class="s1">job.setNumReduceTasks(4);</span></span></p>
<p>2）注意</p>
<p class="_mce_tagged_br">（1）reducetask=0 ，表示没有reduce阶段，输出文件个数和map个数一致。</p>
<p class="_mce_tagged_br">（2）reducetask默认值就是1，所以输出文件个数为一个。</p>
<p class="_mce_tagged_br">（3）如果数据分布不均匀，就有可能在reduce阶段产生数据倾斜</p>
<p class="_mce_tagged_br">（4）reducetask数量并不是任意设置，还要考虑业务逻辑需求，有些情况下，需要计算全局汇总结果，就只能有1个reducetask。</p>
<p class="_mce_tagged_br">（5）具体多少个reducetask，需要根据集群性能而定。</p>
<p class="_mce_tagged_br">（6）如果分区数不是1，但是reducetask为1，是否执行分区过程。答案是：不执行分区过程。因为在maptask的源码中，执行分区的前提是先判断reduceNum个数是否大于1。不大于1肯定不执行。</p>
<p>3）实验：测试reducetask多少合适。</p>
<p><img src="https://images2018.cnblogs.com/blog/1385722/201805/1385722-20180519230628636-107422612.png" alt="" /></p>
<p>4）ReduceTask工作机制</p>
<p><img src="https://images2018.cnblogs.com/blog/1385722/201805/1385722-20180519230730958-1204406808.png" alt="" /></p>
<p class="_mce_tagged_br">（1）Copy阶段：ReduceTask从各个MapTask上远程拷贝一片数据，并针对某一片数据，如果其大小超过一定阈值，则写到磁盘上，否则直接放到内存中。</p>
<p class="_mce_tagged_br">（2）Merge阶段：在远程拷贝数据的同时，ReduceTask启动了两个后台线程对内存和磁盘上的文件进行合并，以防止内存使用过多或磁盘上文件过多。</p>
<p class="_mce_tagged_br">（3）Sort阶段：按照MapReduce语义，用户编写reduce()函数输入数据是按key进行聚集的一组数据。为了将key相同的数据聚在一起，Hadoop采用了基于排序的策略。由于各个MapTask已经实现对自己的处理结果进行了局部排序，因此，ReduceTask只需对所有数据进行一次归并排序即可。</p>
<p class="_mce_tagged_br">（4）Reduce阶段：reduce()函数将计算结果写到HDFS上。</p>
<h3>3.6 OutputFormat数据输出</h3>
<p>3.6.1 OutputFormat接口实现类</p>
<p>OutputFormat是MapReduce输出的基类，所有实现MapReduce输出都实现了 OutputFormat接口。下面我们介绍几种常见的OutputFormat实现类。</p>
<p>1）文本输出TextOutputFormat</p>
<p>默认的输出格式是TextOutputFormat，它把每条记录写为文本行。它的键和值可以是任意类型，因为TextOutputFormat调用toString()方法把它们转换为字符串。</p>
<p>2）SequenceFileOutputFormat</p>
<p>SequenceFileOutputFormat将它的输出写为一个顺序文件。如果输出需要作为后续 MapReduce任务的输入，这便是一种好的输出格式，因为它的格式紧凑，很容易被压缩。</p>
<p>3）自定义OutputFormat</p>
<p>根据用户需求，自定义实现输出。</p>
<p>3.6.2 自定义OutputFormat</p>
<p>为了实现控制最终文件的输出路径，可以自定义OutputFormat。</p>
<p>要在一个mapreduce程序中根据数据的不同输出两类结果到不同目录，这类灵活的输出需求可以通过自定义outputformat来实现。</p>
<p>1）自定义OutputFormat步骤</p>
<p>（1）自定义一个类继承FileOutputFormat。</p>
<p>（2）改写recordwriter，具体改写输出数据的方法write()。</p>
<p>2）实操案例：</p>
<p>详见修改日志内容及自定义日志输出路径（自定义OutputFormat）。</p>
<h3>3.7 计数器应用</h3>
<p>Hadoop为每个作业维护若干内置计数器，以描述多项指标。例如，某些计数器记录已处理的字节数和记录数，使用户可监控已处理的输入数据量和已产生的输出数据量。</p>
<p>1）API</p>
<p>（1）采用枚举的方式统计计数</p>
<div class="cnblogs_code">
<pre>enum MyCounter{MALFORORMED,NORMAL}
//对枚举定义的自定义计数器加1
context.getCounter(MyCounter.MALFORORMED).increment(1); </pre>
</div>
<p>（2）采用计数器组、计数器名称的方式统计</p>
<p><span class="s1">context.getCounter("counterGroup", "countera").increment(1);&nbsp; &nbsp; &nbsp;&nbsp;<span class="s1">组名和计数器名称随便起，但最好有意义。</span></span></p>
<p>（3）计数结果在程序运行后的控制台上查看。</p>
<p>2）案例实操</p>
<p>详见修改日志内容及自定义日志输出路径（自定义OutputFormat）。</p>
<h3>3.8 Join多种应用</h3>
<p>3.8.1 Reduce join</p>
<p>1）原理：</p>
<p>Map端的主要工作：为来自不同表(文件)的key/value对打标签以区别不同来源的记录。然后用连接字段作为key，其余部分和新加的标志作为value，最后进行输出。</p>
<p>reduce端的主要工作：在reduce端以连接字段作为key的分组已经完成，我们只需要在每一个分组当中将那些来源于不同文件的记录(在map阶段已经打标志)分开，最后进行合并就ok了</p>
<p>2）该方法的缺点</p>
<p>这里主要分析一下reduce join的一些不足。之所以会存在reduce join这种方式，是因为整体数据被分割了，每个map task只处理一部分数据而不能够获取到所有需要的join字段，因此我们可以充分利用mapreduce框架的特性，让他按照join key进行分区，将所有join key相同的记录集中起来进行处理，所以reduce join这种方式就出现了。</p>
<p>这种方式的缺点很明显就是会造成map和reduce端也就是shuffle阶段出现大量的数据传输，效率很低。</p>
<p>3.8.2 Map join</p>
<p>1）使用场景：一张表十分小、一张表很大。</p>
<p>2）使用方法：</p>
<p>在提交作业的时候先将小表文件放到该作业的DistributedCache中，然后从DistributeCache中取出该小表进行join (比如放到Hash Map等等容器中)。然后扫描大表，看大表中的每条记录的join key/value值是否能够在内存中找到相同join key的记录，如果有则直接输出结果。</p>
<p>3.8.3 Distributedcache分布式缓存</p>
<p>1）数据倾斜原因</p>
<p>如果是多张表的操作都是在reduce阶段完成，reduce端的处理压力太大，map节点的运算负载则很低，资源利用率不高，且在reduce阶段极易产生数据倾斜。</p>
<p>2）实操案例：</p>
<p>详见 reduce端表合并（数据倾斜）</p>
<p>3）解决方案</p>
<p>在map端缓存多张表，提前处理业务逻辑，这样增加map端业务，减少reduce端数据的压力，尽可能的减少数据倾斜。</p>
<p>4）具体办法：采用distributedcache</p>
<p>（1）在mapper的setup阶段，将文件读取到缓存集合中</p>
<p>（2）在驱动函数中加载缓存。</p>
<p><span class="s1">job.addCacheFile(new URI("file:/e:/mapjoincache/pd.txt"));// 缓存普通文件到task运行节点</span></p>
<p>5）实操案例：</p>
<p>详见 map端表合并（Distributedcache）</p>
<h3>3.9 数据清洗</h3>
<p>1）概述</p>
<p>在运行核心业务Mapreduce程序之前，往往要先对数据进行清洗，清理掉不符合用户要求的数据。清理的过程往往只需要运行mapper程序，不需要运行reduce程序。</p>
<p>2）实操案例</p>
<p>详见 日志清洗（数据清洗）。</p>
<h3><strong>3.10 MapReduce开发总结</strong></h3>
<p><span class="s1">在编写mapreduce程序时，需要考虑的几个方面：</span></p>
<p><span class="s1">1）输入数据接口：InputFormat</span></p>
<p><span class="s1">默认使用的实现类是：TextInputFormat</span></p>
<p><span class="s1">TextInputFormat的功能逻辑是：一次读一行文本，然后将该行的起始偏移量作为key，行内容作为value返回</span></p>
<p><span class="s1">CombineTextInputFormat可以把多个小文件合并成一个切片处理，提高处理效率。</span></p>
<p><span class="s1">用户还可以自定义InputFormat。</span></p>
<p><span class="s1">2）逻辑处理接口：Mapper</span></p>
<p><span class="s1">用户根据业务需求实现其中三个方法：map() setup() cleanup ()&nbsp;</span></p>
<p><span class="s1">3）Partitioner分区</span></p>
<p><span class="s1">有默认实现 HashPartitioner，逻辑是根据key的哈希值和numReduces来返回一个分区号；key.hashCode()&amp;Integer.MAXVALUE % numReduces</span></p>
<p><span class="s1">如果业务上有特别的需求，可以自定义分区。&nbsp;</span></p>
<p><span class="s1">4）Comparable排序</span></p>
<p><span class="s1">当我们用自定义的对象作为key来输出时，就必须要实现WritableComparable接口，重写其中的compareTo()方法。</span></p>
<p><span class="s1">部分排序：对最终输出的没一个文件进行内部排序。</span></p>
<p><span class="s1">全排序：对所有数据进行排序，通常只有一个Reduce。</span></p>
<p><span class="s1">二次排序：排序的条件有两个。&nbsp;</span></p>
<p><span class="s1">5）Combiner合并</span></p>
<p><span class="s1">Combiner合并可以提高程序执行效率，减少io传输。但是使用时必须不能影响原有的业务处理结果。</span></p>
<p><span class="s1">6）reduce端分组：Groupingcomparator</span></p>
<p><span class="s1">reduceTask拿到输入数据（一个partition的所有数据）后，首先需要对数据进行分组，其分组的默认原则是key相同，然后对每一组kv数据调用一次reduce()方法，并且将这一组kv中的第一个kv的key作为参数传给reduce的key，将这一组数据的value的迭代器传给reduce()的values参数。</span></p>
<p><span class="s1">利用上述这个机制，我们可以实现一个高效的分组取最大值的逻辑。</span></p>
<p><span class="s1">自定义一个bean对象用来封装我们的数据，然后改写其compareTo方法产生倒序排序的效果。然后自定义一个Groupingcomparator，将bean对象的分组逻辑改成按照我们的业务分组id来分组（比如订单号）。这样，我们要取的最大值就是reduce()方法中传进来key。</span></p>
<p><span class="s1">7）逻辑处理接口：Reducer</span></p>
<p><span class="s1">用户根据业务需求实现其中三个方法: reduce() setup() cleanup ()</span></p>
<p><span class="s1">8）输出数据接口：OutputFormat</span></p>
<p><span class="s1">默认实现类是TextOutputFormat，功能逻辑是：将每一个KV对向目标文本文件中输出为一行。</span></p>
<p><span class="s1">用户还可以自定义OutputFormat。</span></p>
<h2>四 MapReduce运行方式</h2>
<p>一、本地方式运行：<br />1、pc环境：<br />	1.1、将Hadoop安装本地解压<br />	1.2、配置Hadoop的环境变量<br />		添加%HADOOP_HOME%<br />		修改%PATH%  添加%HADOOP_HOME%/bin;%HADOOP_HOME%/sbin<br />	1.3、在解压的Hadoop的bin目录下 添加winutils.exe工具<br />2、Java工程<br />	2.1、jdk一定要使用自己的jdk、不要使用eclipse自带<br />	2.2、根目录（src目录下），不要添加任何MapReduce的配置文件  hdfs-site.xml yarn-site.xml core-site.xml mapred-site.xml<br />	2.3、在代码当中，通过conf.set方式来进行指定。conf.set("fs.defaultFS", "hdfs://node21:8020");<br />	2.4、修改Hadoop源码<br />3、右键run执行</p>
<p>集群运行两种方式：<br />二、<br />	Java工程<br />	1、根目录（src目录下），添加Hadoop的配置文件 hdfs-site.xml yarn-site.xml core-site.xml mapred-site.xml<br />	2、在代码当中，指定jar包的位置，config.set("mapred.jar", "D:\\MR\\wc.jar");<br />	3、修改Hadoop源码<br />	4、将工程打jar包<br />	5、右键run执行</p>
<p>三、<br />	Java工程<br />	1、根目录（src目录下），添加Hadoop的配置文件 hdfs-site.xml  yarn-site.xml core-site.xml mapred-site.xml<br />	2、将工程打jar包<br />	3、手动将jar包上传到集群当中<br />	4、通过hadoop命令来运行。hadoop jar jar位置 mr代码入口 （例如：hadoop jar /usr/wc.jar com.sxt.mr.WcJob）</p>
<p>HBase运行：<br />在代码当中指定HBase所使用的ZooKeeper集群。<br />（注意：如果hbase搭建的是伪分布式，那么对应的ZooKeeper就是那台伪分布式的服务器）<br />conf.set("hbase.zookeeper.quorum", "node21,node22,node23");</p>
<p>System.setProperty("HADOOP_USER_NAME", "root");</p></div>

</body>
</html>
